/**
 * 腾讯云COS文件服务类
 * 封装COS操作API
 */
import COS from 'cos-js-sdk-v5';
import { ElMessage } from 'element-plus';
import { formatPath, getCosFileUrl, cosConfig } from '../utils/cosConfig';
import { getFileType } from '../utils/dataService';

class CosFileService {
  constructor() {
    this.cos = null;
    this.config = {};
    this.isInitialized = false;
    
    // 尝试使用默认配置初始化
    this.init(cosConfig);
  }

  /**
   * 初始化COS服务
   * @param {Object} config - 配置参数
   * @returns {Boolean} 是否初始化成功
   */
  init(config) {
    try {
      // 检查必要配置
      if (!config.Bucket || !config.Region) {
        console.error('COS初始化失败: 缺少必要的配置参数');
        return false;
      }
      
      // 保存配置
      this.config = { ...config };
      
      // 确保路径前缀格式正确
      if (this.config.Prefix) {
        // 处理可能的多余斜杠
        this.config.Prefix = this.config.Prefix.replace(/\/+$/, '') + '/';
        console.log('初始化COS服务，标准化前缀:', this.config.Prefix);
      } else {
        this.config.Prefix = '';
      }
      
      // 创建COS实例
      if (config.useAnonymous) {
        // 匿名模式
        this.cos = new COS({
          // 必选参数
          getAuthorization: function (options, callback) {
            callback({
              TmpSecretId: '',
              TmpSecretKey: '',
              XCosSecurityToken: '',
              ExpiredTime: 0
            });
          }
        });
      } else {
        // 密钥模式
        if (!config.SecretId || !config.SecretKey) {
          console.error('COS初始化失败: 非匿名模式下缺少密钥配置');
          return false;
        }
        
        this.cos = new COS({
          SecretId: config.SecretId,
          SecretKey: config.SecretKey
        });
      }
      
      this.isInitialized = true;
      return true;
    } catch (error) {
      console.error('COS初始化失败:', error);
      this.isInitialized = false;
      return false;
    }
  }

  /**
   * 列出指定路径下的文件和目录
   * @param {String} path - 路径，相对于配置的Prefix
   * @returns {Promise<Object>} 包含文件和目录的对象
   */
  async listFiles(path = '') {
    if (!this.isInitialized) {
      throw new Error('COS服务未初始化');
    }
    
    // 构建完整路径，确保不会有多余的斜杠
    let fullPath = this.config.Prefix;
    if (path) {
      // 移除路径开头和结尾的斜杠，然后添加到前缀后面
      const cleanPath = path.replace(/^\/+/, '').replace(/\/+$/, '');
      fullPath = cleanPath ? `${fullPath}${cleanPath}/` : fullPath;
    }
    
    console.log('构建完整路径:', {
      配置前缀: this.config.Prefix,
      请求路径: path,
      完整路径: fullPath
    });
    
    try {
      // 获取文件列表
      const data = await new Promise((resolve, reject) => {
        this.cos.getBucket({
          Bucket: this.config.Bucket,
          Region: this.config.Region,
          Prefix: fullPath,
          Delimiter: '/',
          MaxKeys: 1000
        }, (err, data) => {
          if (err) {
            reject(err);
          } else {
            resolve(data);
          }
        });
      });
      
      // 处理目录
      const directories = (data.CommonPrefixes || []).map(item => {
        // 修复：确保不会出现多余的斜杠
        const name = item.Prefix.replace(fullPath, '').replace(/\/$/, '');
        console.log('目录路径处理:', {
          原始路径: item.Prefix,
          完整前缀: fullPath,
          处理后名称: name
        });
        return {
          name,
          prefix: item.Prefix,
          key: item.Prefix,
          type: 'directory',
          size: '-',
          updateTime: '-',
          isDirectory: true
        };
      });
      
      // 处理文件
      const files = (data.Contents || [])
        .filter(item => item.Key !== fullPath) // 排除当前目录
        .map(item => {
          const name = item.Key.replace(fullPath, '');
          // 跳过以/结尾的条目（这些实际上是目录）
          if (name.endsWith('/')) return null;
          
          // 获取文件类型
          const fileType = getFileType(name);
          
          // 构建文件URL
          const url = this.getFileUrl(item.Key);
          
          // 格式化文件大小
          const size = this.formatFileSize(item.Size);
          
          // 格式化更新时间
          const updateTime = new Date(item.LastModified).toLocaleString();
          
          return {
            name,
            key: item.Key,
            url,
            type: fileType,
            size,
            updateTime,
            isDirectory: false
          };
        })
        .filter(Boolean); // 过滤掉null值
      
      return { directories, files };
    } catch (error) {
      console.error('获取文件列表失败:', error);
      throw error;
    }
  }

  /**
   * 上传文件
   * @param {File} file - 文件对象
   * @param {String} prefix - 目录前缀
   * @param {Function} onProgress - 上传进度回调
   * @returns {Promise<Object>} 上传结果
   */
  uploadFile(file, prefix = '', onProgress = null) {
    if (!this.isInitialized) {
      return Promise.reject(new Error('COS服务尚未初始化'));
    }

    const fullPrefix = this.config.Prefix + prefix;
    const key = fullPrefix + file.name;

    return new Promise((resolve, reject) => {
      this.cos.putObject({
        Bucket: this.config.Bucket,
        Region: this.config.Region,
        Key: key,
        Body: file,
        onProgress: onProgress
      }, (err, data) => {
        if (err) {
          reject(err);
        } else {
          // 构造上传结果
          resolve({
            id: key,
            name: file.name,
            type: this.getFileType(file.name),
            size: this.formatFileSize(file.size),
            updateTime: new Date().toLocaleDateString(),
            category: '上传文件',
            key: key,
            url: this.getFileUrl(key)
          });
        }
      });
    });
  }

  /**
   * 创建文件夹
   * @param {String} name - 文件夹名称
   * @param {String} prefix - 目录前缀
   * @returns {Promise<Object>} 创建结果
   */
  createFolder(name, prefix = '') {
    if (!this.isInitialized) {
      return Promise.reject(new Error('COS服务尚未初始化'));
    }

    const fullPrefix = this.config.Prefix + prefix;
    const folderKey = `${fullPrefix}${name}/`;

    return new Promise((resolve, reject) => {
      this.cos.putObject({
        Bucket: this.config.Bucket,
        Region: this.config.Region,
        Key: folderKey,
        Body: ''
      }, (err, data) => {
        if (err) {
          reject(err);
        } else {
          resolve({
            id: folderKey,
            name: name,
            type: 'directory',
            prefix: folderKey,
            size: '-',
            updateTime: new Date().toLocaleDateString(),
            category: '文件夹'
          });
        }
      });
    });
  }

  /**
   * 删除文件
   * @param {String} key - 文件Key
   * @returns {Promise<Object>} 删除结果
   */
  deleteFile(key) {
    if (!this.isInitialized) {
      return Promise.reject(new Error('COS服务尚未初始化'));
    }

    return new Promise((resolve, reject) => {
      this.cos.deleteObject({
        Bucket: this.config.Bucket,
        Region: this.config.Region,
        Key: key
      }, (err, data) => {
        if (err) {
          reject(err);
        } else {
          resolve(data);
        }
      });
    });
  }

  /**
   * 获取文件URL
   * @param {String} key - 文件Key
   * @returns {String} 文件URL
   */
  getFileUrl(key) {
    if (this.config.cdnDomain) {
      // 如果配置了CDN域名，则使用CDN域名
      return `${this.config.cdnDomain}/${key}`;
    } else if (this.config.Domain) {
      // 如果有自定义域名，直接使用
      return `${this.config.Domain}/${key}`;
    }
    
    // 否则使用COS默认域名
    return `https://${this.config.Bucket}.cos.${this.config.Region}.myqcloud.com/${key}`;
  }

  /**
   * 获取文件类型
   * @param {String} fileName - 文件名
   * @returns {String} 文件类型
   */
  getFileType(fileName) {
    const extension = fileName.split('.').pop().toLowerCase();
    
    if (['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'html', 'htm'].includes(extension)) {
      return 'document';
    } else if (['md', 'markdown'].includes(extension)) {
      return 'markdown';
    } else if (['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'].includes(extension)) {
      return 'image';
    } else if (['mp4', 'avi', 'mov', 'wmv', 'flv'].includes(extension)) {
      return 'video';
    } else if (['mp3', 'wav', 'ogg', 'flac'].includes(extension)) {
      return 'audio';
    } else if (['zip', 'rar', '7z', 'tar', 'gz'].includes(extension)) {
      return 'archive';
    }
    
    return 'other';
  }

  /**
   * 格式化文件大小
   * @param {Number} size - 文件大小（字节）
   * @returns {String} 格式化后的文件大小
   */
  formatFileSize(size) {
    if (size < 1024) {
      return size + ' B';
    } else if (size < 1024 * 1024) {
      return (size / 1024).toFixed(2) + ' KB';
    } else if (size < 1024 * 1024 * 1024) {
      return (size / 1024 / 1024).toFixed(2) + ' MB';
    } else {
      return (size / 1024 / 1024 / 1024).toFixed(2) + ' GB';
    }
  }

  /**
   * 下载文件
   * @param {String} key 文件完整路径键
   * @param {String} fileName 下载后的文件名
   */
  async downloadFile(key, fileName) {
    if (!this.isInitialized) {
      throw new Error('COS服务尚未初始化，请先初始化');
    }
    
    if (!key) {
      throw new Error('文件路径不能为空');
    }
    
    try {
      const url = getCosFileUrl(key, this.config);
      
      // 创建下载链接并模拟点击
      const link = document.createElement('a');
      link.href = url;
      link.download = fileName || key.split('/').pop();
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
      
      ElMessage.success('文件下载已开始');
      return true;
    } catch (error) {
      console.error('下载文件失败:', error);
      ElMessage.error('下载文件失败: ' + (error.message || '未知错误'));
      return false;
    }
  }
}

// 导出单例
export default new CosFileService(); 